Den här frågan har redan svar här:
Ingen implicit konvertering hos överbelastad operatör
(2 svar)
Stängt för 7 år sedan.
Jag skriver ett enkelt omslag för en elementär typ och försöker undvika att behöva skriva för många smaker av standardoperatörer. Jag hoppades att implicit typkonvertering skulle hjälpa, men det gör det inte. Här är ett avskalat exempel:
struct Int
{
int _i;
Int (int i = 0): _i {i} {}
Int-operator + (const Int & rhs) {return _i + rhs._i;}
};
int main (int argc, char * argv [])
{
(ogiltig) (Int (1) + 2); // Fina
(ogiltig) (2 + Int (1)); // fel: ogiltiga operander till binärt uttryck ('int' och 'Int')
}
Jag använder llvm. Den första raden av huvudkompilerar bra. Den andra orsakar ett fel. Nu, vad jag hoppades skulle hända i andra raden är att 2 implicit skulle konverteras till Int (2), följt av ett samtal till operatör +. Varför händer det inte? Varför sker den implicita omvandlingen i första raden?
2021-03-01 08:19:27
Det händer på första raden eftersom den enda operatören + som är tillgänglig är operator + (Int &) (som har en implicit första parameter för Int för den här instansen). Den andra raden misslyckas eftersom den första parametern är en int och den har ingen aning om att den behöver konvertera den innan operationen försöks (den vet inte att den behöver använda Int :: operator +).
Du kan undvika detta problem genom att göra operatören till en icke-vän-funktion (http://ideone.com/YCf7wX)
struct Int
{
int _i;
Int (int i = 0): _i {i} {}
vän Int-operatör + (const Int & lhs, const Int & rhs);
};
Int operator + (const Int & lhs, const Int & rhs)
{
returnera lhs._i + rhs._i;
}
int main ()
{
Int i;
i + 5;
5 + i;
returnera 0;
}
|
Inte svaret du letar efter? Bläddra bland andra frågor taggade c ++ operatör-nyckelord implicit-konvertering eller ställ din egen fråga.